// 导入小程序应用实例和工具库
const app = getApp()
// 获取数据库引用和数据库操作命令
const db = wx.cloud.database()
const _ = db.command
const util = require('../../utils/util.js')

// 教师班级管理页面
Page({
  // 页面初始数据
  data: {
    classes: [], // 班级列表
    currentClass: null, // 当前选中班级
    students: [], // 学生列表
    abnormalStudents: [], // 需要关注的学生
    
    showClassModal: false, // 添加/编辑班级模态框显示
    showClassDetailModal: false, // 班级详情模态框显示
    showAddStudentModal: false, // 添加学生模态框显示
    
    isEditMode: false, // 是否是编辑模式
    classForm: { // 班级表单数据
      name: '', // 班级名称
      department: '', // 所属院系
      grade: '' // 年级
    },
    
    studentForm: { // 学生表单数据
      name: '', // 学生姓名
      studentId: '', // 学号
      phone: '', // 联系电话
      dormitory: '' // 宿舍号
    },
    
    currentTab: 'students', // 当前选中的标签页 students/statistics
    
    userInfo: null, // 当前用户信息
    searchValue: '', // 搜索关键词
    studentSearchValue: '' // 学生搜索关键词
  },
  
  // 页面加载时执行
  onLoad: function() {
    this.getUserInfo()
  },
  
  // 获取当前登录用户信息
  getUserInfo: function() {
    // 从本地存储获取用户信息
    const userInfo = wx.getStorageSync('userInfo')
    if (userInfo) {
      // 存在用户信息则加载班级
      this.setData({ userInfo })
      this.loadClasses()
    } else {
      // 未登录则提示并跳转到个人中心
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        success: () => {
          setTimeout(() => {
            wx.switchTab({
              url: '/pages/profile/profile',
            })
          }, 1500)
        }
      })
    }
  },
  
  // 返回上一页
  goBack: function() {
    wx.navigateBack({
      delta: 1
    })
  },
  
  // 加载班级列表数据
  loadClasses: function() {
    // 显示加载提示
    wx.showLoading({ title: '加载中' })
    
    const userInfo = this.data.userInfo
    console.log('loadClasses - userInfo:', userInfo)
    console.log('loadClasses - userInfo.classes:', userInfo.classes)
    
    // 检查用户权限
    if (!userInfo || userInfo.role !== 'teacher') {
      wx.hideLoading()
      wx.showToast({
        title: '您没有权限访问此页面',
        icon: 'none'
      })
      return
    }
    
    // 构建查询条件，获取教师管理的班级
    let classQuery = db.collection('classes')
    if (userInfo.classes && Array.isArray(userInfo.classes) && userInfo.classes.length > 0) {
      console.log('loadClasses - 使用classes数组查询:', userInfo.classes)
      classQuery = classQuery.where({
        name: _.in(userInfo.classes) // 使用数组中的班级名称查询
      })
    } else {
      console.log('loadClasses - 没有classes信息，使用默认查询')
    }
    
    // 执行查询获取班级数据
    classQuery.get().then(res => {
      console.log('loadClasses - 查询结果:', res.data)
      // 获取每个班级的学生数量
      const classes = res.data
      if (classes.length === 0) {
        console.log('loadClasses - 没有找到班级数据')
        wx.hideLoading()
        return
      }
      
      // 为每个班级查询学生数量
      const promises = classes.map(cls => {
        console.log('loadClasses - 处理班级:', cls)
        return db.collection('users')
          .where({
            classes: _.all([cls._id]), // 使用classes字段查询学生
            role: 'student' // 只查询学生角色
          })
          .count()
          .then(countRes => {
            // 将学生数量添加到班级对象
            cls.studentCount = countRes.total
            console.log('loadClasses - 班级学生数:', cls.name, countRes.total)
            return cls
          })
      })
      
      // 等待所有班级学生数量查询完成
      Promise.all(promises).then(updatedClasses => {
        console.log('loadClasses - 最终班级列表:', updatedClasses)
        this.setData({
          classes: updatedClasses
        })
        wx.hideLoading()
      })
    }).catch(err => {
      // 错误处理
      console.error('获取班级列表失败', err)
      wx.hideLoading()
      wx.showToast({
        title: '获取班级列表失败',
        icon: 'none'
      })
    })
  },
  
  // 搜索班级功能
  onSearchInput: function(e) {
    // 获取搜索关键词并去除空格
    const searchValue = e.detail.value.trim()
    this.setData({ searchValue })
    
    // 空关键词时重新加载所有班级
    if (searchValue === '') {
      this.loadClasses()
      return
    }
    
    // 构建班级搜索查询
    const userInfo = this.data.userInfo
    let classQuery = db.collection('classes')
    
    // 限制只查询教师管理的班级
    if (userInfo.classes && Array.isArray(userInfo.classes) && userInfo.classes.length > 0) {
      classQuery = classQuery.where({
        name: _.in(userInfo.classes)
      })
    }
    
    // 使用正则表达式进行模糊查询
    classQuery.where({
      name: db.RegExp({
        regexp: searchValue, // 匹配班级名称
        options: 'i' // 不区分大小写
      })
    }).get().then(res => {
      // 更新班级列表
      const classes = res.data
      this.setData({ classes })
    })
  },
  
  // 显示添加班级的模态框
  showAddClassModal: function() {
    // 重置表单数据并显示模态框
    this.setData({
      showClassModal: true,
      isEditMode: false,
      classForm: {
        name: '',
        department: '',
        grade: ''
      }
    })
  },
  
  // 显示编辑班级的模态框
  editClass: function(e) {
    // 获取要编辑的班级ID
    const classId = e.currentTarget.dataset.id
    // 在班级列表中查找对应班级对象
    const classObj = this.data.classes.find(cls => cls._id === classId)
    
    if (classObj) {
      // 使用班级数据填充表单并显示模态框
      this.setData({
        showClassModal: true,
        isEditMode: true,
        classForm: {
          name: classObj.name || '',
          department: classObj.department || '',
          grade: classObj.grade || ''
        },
        currentEditClassId: classId // 记录当前编辑的班级ID
      })
    }
  },
  
  // 隐藏班级模态框
  hideClassModal: function() {
    this.setData({
      showClassModal: false
    })
  },
  
  // 处理班级名称输入
  onClassNameInput: function(e) {
    this.setData({
      'classForm.name': e.detail.value
    })
  },
  
  // 处理院系输入
  onDepartmentInput: function(e) {
    this.setData({
      'classForm.department': e.detail.value
    })
  },
  
  // 处理年级输入
  onGradeInput: function(e) {
    this.setData({
      'classForm.grade': e.detail.value
    })
  },
  
  // 保存班级信息（添加或编辑）
  saveClass: function() {
    // 获取表单数据和编辑状态
    const { classForm, isEditMode, currentEditClassId, userInfo } = this.data
    
    // 验证班级名称不能为空
    if (!classForm.name.trim()) {
      wx.showToast({
        title: '请输入班级名称',
        icon: 'none'
      })
      return
    }
    
    // 显示保存中提示
    wx.showLoading({ title: '保存中' })
    
    if (isEditMode) {
      // 编辑现有班级的处理逻辑
      db.collection('classes').doc(currentEditClassId).update({
        data: {
          name: classForm.name, // 更新班级名称
          department: classForm.department, // 更新所属院系
          grade: classForm.grade, // 更新年级
          updateTime: db.serverDate() // 更新时间
        }
      }).then(() => {
        // 编辑成功处理
        wx.hideLoading()
        wx.showToast({
          title: '修改成功',
          icon: 'success'
        })
        this.hideClassModal()
        this.loadClasses() // 重新加载班级列表
      }).catch(err => {
        // 编辑失败处理
        console.error('修改班级失败', err)
        wx.hideLoading()
        wx.showToast({
          title: '修改失败',
          icon: 'none'
        })
      })
    } else {
      // 添加新班级的处理逻辑
      db.collection('classes').add({
        data: {
          name: classForm.name, // 班级名称
          department: classForm.department, // 所属院系
          grade: classForm.grade, // 年级
          counselorId: userInfo._id, // 关联到当前教师
          createTime: db.serverDate(), // 创建时间
          updateTime: db.serverDate() // 更新时间
        }
      }).then(res => {
        // 获取新班级ID和名称
        const classId = res._id
        const className = classForm.name
        
        // 更新当前用户负责的班级列表
        let classes = []
        if (userInfo.classes && Array.isArray(userInfo.classes)) {
          classes = [...userInfo.classes]
        }
        
        // 添加新班级到用户班级列表（避免重复）
        if (!classes.includes(className)) {
          classes.push(className)
        }
        
        // 更新用户信息到数据库
        db.collection('users').doc(userInfo._id).update({
          data: {
            classes: classes, // 更新班级列表
            updateTime: db.serverDate() // 更新时间
          }
        }).then(() => {
          // 更新本地存储的用户信息
          userInfo.classes = classes
          // 确保移除旧版class字段（兼容性处理）
          if (userInfo.hasOwnProperty('class')) {
            delete userInfo.class
          }
          wx.setStorageSync('userInfo', userInfo)
          
          // 更新页面数据
          this.setData({
            userInfo: userInfo
          })
          
          // 隐藏模态框并重新加载班级列表
          this.hideClassModal()
          this.loadClasses()
          wx.showToast({
            title: '添加成功',
            icon: 'success'
          })
        }).catch(err => {
          // 更新用户信息失败处理
          console.error('更新用户班级信息失败', err)
          wx.hideLoading()
          wx.showToast({
            title: '添加成功，但更新用户信息失败',
            icon: 'none'
          })
        })
      }).catch(err => {
        // 添加班级失败处理
        console.error('添加班级失败', err)
        wx.hideLoading()
        wx.showToast({
          title: '添加失败',
          icon: 'none'
        })
      })
    }
  },
  
  // 显示删除班级确认对话框
  confirmDeleteClass: function(e) {
    // 获取要删除的班级ID和对象
    const classId = e.currentTarget.dataset.id
    const classObj = this.data.classes.find(cls => cls._id === classId)
    
    // 显示确认对话框
    wx.showModal({
      title: '确认删除',
      content: `确定要删除班级"${classObj.name}"吗？此操作不可恢复，且会影响该班级的所有学生。`,
      confirmColor: '#f44336',
      success: (res) => {
        if (res.confirm) {
          // 用户确认后执行删除
          this.deleteClass(classId, classObj.name)
        }
      }
    })
  },
  
  // 执行删除班级操作
  deleteClass: function(classId, className) {
    // 显示删除中提示
    wx.showLoading({ title: '删除中' })
    
    // 从用户的班级列表中移除该班级
    const userInfo = this.data.userInfo
    let classes = []
    if (userInfo.classes && Array.isArray(userInfo.classes)) {
      classes = userInfo.classes.filter(name => name !== className)
    }
    
    // 更新用户信息到数据库
    db.collection('users').doc(userInfo._id).update({
      data: {
        classes: classes, // 更新后的班级列表
        updateTime: db.serverDate() // 更新时间
      }
    }).then(() => {
      // 更新本地存储的用户信息
      userInfo.classes = classes
      // 确保移除旧版class字段（兼容性处理）
      if (userInfo.hasOwnProperty('class')) {
        delete userInfo.class
      }
      wx.setStorageSync('userInfo', userInfo)
      
      // 从数据库删除班级记录
      db.collection('classes').doc(classId).remove().then(() => {
        // 删除成功后重新加载班级列表
        this.loadClasses()
        wx.showToast({
          title: '删除成功',
          icon: 'success'
        })
      }).catch(err => {
        // 删除班级失败处理
        console.error('删除班级失败', err)
        wx.hideLoading()
        wx.showToast({
          title: '删除班级失败',
          icon: 'none'
        })
      })
    }).catch(err => {
      // 更新用户信息失败处理
      console.error('更新用户班级信息失败', err)
      wx.hideLoading()
      wx.showToast({
        title: '删除失败',
        icon: 'none'
      })
    })
  },
  
  // 选择班级显示详情
  selectClass: function(e) {
    const classId = e.currentTarget.dataset.id
    this.setData({
      currentClass: classId,
      currentTab: 'students'
    })
    
    this.loadClassDetail(classId)
  },
  
  // 加载班级详情
  loadClassDetail: function(classId) {
    wx.showLoading({ title: '加载中' })
    
    // 获取班级信息
    db.collection('classes').doc(classId).get().then(res => {
      const classInfo = res.data
      
      // 获取班级学生
      this.loadStudents(classId)
      
      // 获取异常学生
      this.loadAbnormalStudents(classId)
      
      this.setData({
        currentClass: classInfo,
        showClassDetailModal: true
      })
      
      wx.hideLoading()
    }).catch(err => {
      console.error('获取班级详情失败', err)
      wx.hideLoading()
      wx.showToast({
        title: '获取班级详情失败',
        icon: 'none'
      })
    })
  },
  
  // 加载班级学生
  loadStudents: function(classId) {
    console.log('开始加载班级学生, classId:', classId);
    
    // 获取班级信息先
    db.collection('classes').doc(classId).get().then(classRes => {
      const className = classRes.data.name;
      console.log('获取到班级名称:', className);
      
      // 构建复合查询条件，同时支持classes和class字段
      const _ = db.command;
      const condition = _.or([
        {
          classes: _.all([classId]), // 新结构：使用classes数组字段
          role: 'student'
        },
        {
          class: classId, // 旧结构：使用班级ID
          role: 'student'
        },
        {
          class: className, // 旧结构：使用班级名称
          role: 'student'
        }
      ]);
      
      return db.collection('users')
        .where(condition)
        .get();
    }).then(res => {
      console.log('查询到的学生数据:', res.data);
      console.log('学生数量:', res.data.length);
      this.setData({
        students: res.data
      });
      
      // 如果找到了使用旧结构的学生，自动迁移到新结构
      const studentsToUpdate = res.data.filter(s => s.class && !s.classes);
      if (studentsToUpdate.length > 0) {
        this.migrateStudentsToNewStructure(studentsToUpdate, classId);
      }
    }).catch(err => {
      console.error('获取学生列表失败', err);
    });
  },
  
  // 迁移学生数据结构
  migrateStudentsToNewStructure: function(students, classId) {
    console.log('开始迁移学生数据结构, 数量:', students.length);
    const db = wx.cloud.database();
    
    students.forEach(student => {
      db.collection('users').doc(student._id).update({
        data: {
          classes: [classId], // 添加classes字段，使用数组结构
          updateTime: db.serverDate()
        }
      }).then(() => {
        console.log('学生数据结构迁移成功:', student.name);
      }).catch(err => {
        console.error('学生数据结构迁移失败:', student.name, err);
      });
    });
  },
  
  // 加载异常学生
  loadAbnormalStudents: function(classId) {
    // 获取班级信息先
    db.collection('classes').doc(classId).get().then(classRes => {
      const className = classRes.data.name;
      console.log('获取到班级名称:', className);
      
      // 构建复合查询条件，同时支持classes和class字段
      const _ = db.command;
      const condition = _.or([
        {
          classes: _.all([classId]), // 新结构：使用classes数组字段
          role: 'student'
        },
        {
          class: classId, // 旧结构：使用班级ID
          role: 'student'
        },
        {
          class: className, // 旧结构：使用班级名称
          role: 'student'
        }
      ]);
      
      return db.collection('users')
        .where(condition)
        .get();
    }).then(res => {
      const students = res.data
      const studentIds = students.map(student => student._id)
      
      if (studentIds.length === 0) {
        this.setData({
          abnormalStudents: []
        })
        return
      }
      
      // 获取最近的心理测试结果
      db.collection('psychological_tests')
        .where({
          userId: _.in(studentIds)
        })
        .orderBy('createTime', 'desc')
        .get()
        .then(testRes => {
          // 按学生ID分组，找出最近的测试记录
          const latestTests = {}
          testRes.data.forEach(test => {
            if (!latestTests[test.userId] || new Date(test.createTime) > new Date(latestTests[test.userId].createTime)) {
              latestTests[test.userId] = test
            }
          })
          
          // 找出异常学生
          const abnormalStudents = students.filter(student => {
            const latestTest = latestTests[student._id]
            return latestTest && (latestTest.level === 'moderate' || latestTest.level === 'severe')
          }).map(student => {
            const latestTest = latestTests[student._id]
            let riskLevel = 'normal'
            let riskLevelText = '正常'
            
            if (latestTest) {
              if (latestTest.level === 'severe') {
                riskLevel = 'severe'
                riskLevelText = '重度异常'
              } else if (latestTest.level === 'moderate') {
                riskLevel = 'moderate'
                riskLevelText = '中度异常'
              } else if (latestTest.level === 'mild') {
                riskLevel = 'mild'
                riskLevelText = '轻度异常'
              }
            }
            
            return {
              ...student,
              riskLevel,
              riskLevelText
            }
          })
          
          this.setData({
            abnormalStudents: abnormalStudents
          })
          
          // 更新当前班级异常学生数量
          this.setData({
            'currentClass.abnormalCount': abnormalStudents.length
          })
        })
    })
  },
  
  // 隐藏班级详情模态框
  hideClassDetailModal: function() {
    this.setData({
      showClassDetailModal: false
    })
  },
  
  // 切换标签页
  switchTab: function(e) {
    const tab = e.currentTarget.dataset.tab
    this.setData({
      currentTab: tab
    })
    
    // 如果切换到统计标签，初始化图表
    if (tab === 'statistics') {
      this.initCharts()
    }
  },
  
  // 初始化图表
  initCharts: function() {
    // 由于微信小程序图表需要额外的组件，这里仅提供一个结构
    // 实际开发中需要引入图表组件如 wx-charts 或 echarts-for-weixin
    console.log('初始化图表')
  },
  
  // 学生搜索
  onStudentSearchInput: function(e) {
    const searchValue = e.detail.value.trim()
    this.setData({ studentSearchValue: searchValue })
    
    const classId = this.data.currentClass._id
    
    if (searchValue === '') {
      this.loadStudents(classId)
      return
    }
    
    db.collection('users')
      .where({
        classes: _.all([classId]),
        role: 'student',
        name: db.RegExp({
          regexp: searchValue,
          options: 'i'
        })
      })
      .get()
      .then(res => {
        this.setData({
          students: res.data
        })
      })
  },
  
  // 显示添加学生模态框
  showAddStudentModal: function() {
    this.setData({
      showAddStudentModal: true,
      studentForm: {
        name: '',
        studentId: '',
        phone: '',
        dormitory: ''
      }
    })
  },
  
  // 隐藏添加学生模态框
  hideAddStudentModal: function() {
    this.setData({
      showAddStudentModal: false
    })
  },
  
  // 学生表单输入处理
  onStudentNameInput: function(e) {
    this.setData({
      'studentForm.name': e.detail.value
    })
  },
  
  onStudentIdInput: function(e) {
    this.setData({
      'studentForm.studentId': e.detail.value
    })
  },
  
  onStudentPhoneInput: function(e) {
    this.setData({
      'studentForm.phone': e.detail.value
    })
  },
  
  onDormitoryInput: function(e) {
    this.setData({
      'studentForm.dormitory': e.detail.value
    })
  },
  
  // 添加学生
  addStudent: function() {
    const { studentForm, currentClass } = this.data
    
    if (!studentForm.name || !studentForm.studentId) {
      wx.showToast({
        title: '姓名和学号不能为空',
        icon: 'none'
      })
      return
    }
    
    wx.showLoading({ title: '添加中' })
    
    // 查询是否已经存在该学号的学生
    db.collection('users')
      .where({
        studentId: studentForm.studentId,
        role: 'student'
      })
      .get()
      .then(res => {
        if (res.data.length > 0) {
          // 已存在该学生，将其添加到当前班级
          const existingStudent = res.data[0];
          let updateData = {};
          
          if (existingStudent.classes && Array.isArray(existingStudent.classes)) {
            // 新结构：如果没有当前班级ID，则添加
            if (!existingStudent.classes.includes(currentClass._id)) {
              updateData.classes = _.push(currentClass._id);
            } else {
              // 已在该班级，提示用户
              wx.hideLoading();
              wx.showToast({
                title: '该学生已在此班级',
                icon: 'none'
              });
              return Promise.reject('already_in_class');
            }
          } else {
            // 旧结构：创建新的classes数组，包含当前班级ID
            // 同时，保留原有class值（如果有）
            updateData.classes = [currentClass._id];
          }
          
          updateData.updateTime = db.serverDate();
          
          // 如果用户提供了新的电话或宿舍信息，也更新这些字段
          if (studentForm.phone && studentForm.phone.trim()) {
            updateData.phone = studentForm.phone;
          }
          if (studentForm.dormitory && studentForm.dormitory.trim()) {
            updateData.dormitory = studentForm.dormitory;
          }
          
          return db.collection('users').doc(existingStudent._id).update({
            data: updateData
          });
        } else {
          // 添加新学生
          return db.collection('users').add({
            data: {
              name: studentForm.name,
              studentId: studentForm.studentId,
              phone: studentForm.phone || '',
              dormitory: studentForm.dormitory || '',
              classes: [currentClass._id], // 使用新结构
              role: 'student',
              createTime: db.serverDate(),
              updateTime: db.serverDate()
            }
          });
        }
      })
      .then(() => {
        // 更新学生列表
        this.loadStudents(currentClass._id);
        this.hideAddStudentModal();
        wx.showToast({
          title: '添加成功',
          icon: 'success'
        });
        
        // 更新班级学生数量
        const studentCount = (this.data.currentClass.studentCount || 0) + 1;
        this.setData({
          'currentClass.studentCount': studentCount
        });
      })
      .catch(err => {
        if (err === 'already_in_class') return; // 已处理的错误
        console.error('添加学生失败', err);
        wx.hideLoading();
        wx.showToast({
          title: '添加失败',
          icon: 'none'
        });
      });
  },
  
  // 查看学生详情
  viewStudentDetail: function(e) {
    const studentId = e.currentTarget.dataset.id
    // 跳转到学生详情页
    wx.navigateTo({
      url: `/pages/student-detail/index?id=${studentId}`,
    })
  },
  
  // 确认移除学生
  confirmRemoveStudent: function(e) {
    const studentId = e.currentTarget.dataset.id
    const student = this.data.students.find(s => s._id === studentId)
    
    wx.showModal({
      title: '确认移除',
      content: `确定要将学生"${student.name}"从班级中移除吗？`,
      confirmColor: '#f44336',
      success: (res) => {
        if (res.confirm) {
          this.removeStudent(studentId)
        }
      }
    })
  },
  
  // 移除学生
  removeStudent: function(studentId) {
    const { currentClass } = this.data
    
    wx.showLoading({ title: '移除中' })
    
    // 获取学生信息
    db.collection('users').doc(studentId).get().then(res => {
      const studentData = res.data;
      const updateData = {};
      
      // 处理不同的数据结构
      if (studentData.classes && Array.isArray(studentData.classes)) {
        // 新结构：从classes数组中移除当前班级ID
        updateData.classes = _.pull(currentClass._id);
      } else {
        // 旧结构：清空class字段，并添加空的classes数组
        updateData.class = '';
        updateData.classes = [];
      }
      
      updateData.updateTime = db.serverDate();
      
      // 更新学生班级信息
      return db.collection('users').doc(studentId).update({
        data: updateData
      });
    }).then(() => {
      // 更新学生列表
      this.loadStudents(currentClass._id)
      wx.showToast({
        title: '移除成功',
        icon: 'success'
      })
      
      // 更新班级学生数量
      const studentCount = Math.max((this.data.currentClass.studentCount || 0) - 1, 0)
      this.setData({
        'currentClass.studentCount': studentCount
      })
    }).catch(err => {
      console.error('移除学生失败', err)
      wx.hideLoading()
      wx.showToast({
        title: '移除失败',
        icon: 'none'
      })
    })
  },
  
  // 开始干预
  startIntervention: function(e) {
    const studentId = e.currentTarget.dataset.id
    // 跳转到干预页面
    wx.navigateTo({
      url: `/pages/intervention/index?id=${studentId}`,
    })
  }
}) 